package day12.homework;

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public
class Demo {
    static
    Random r=new Random();
    public static
    void main(String[] args) {
        demo1();
    }
    //b.使用newFixedThreadPool处理批量任务
    //题目描述：编写一个程序，使用newFixedThreadPool创建一个固定大小的线程池来处理一批任务。每个任务模拟一个耗时操作（例如，睡眠一段时间），并输出任务开始和结束的时间。要求：
    //创建一个包含10个任务的列表，每个任务睡眠1-3秒之间的随机时间。
    //使用固定大小为5的线程池来执行这些任务。
    //输出每个任务的开始和结束时间，以及任务的总执行时间
    public static void demo(){
        ExecutorService es= Executors.newFixedThreadPool(5);
        String[] names={"起床","洗漱","吃早餐","学习","吃午餐","学习","休息","吃晚餐","学习","睡觉"};
        long start=System.currentTimeMillis();
        for (int i=0;i<names.length;i++){
            long time=System.currentTimeMillis();
            String name=names[i];
            es.execute(()->{
                try {
                    System.out.println("开始"+name+"，开始时间为："+time);
                    Thread.sleep(new Random().nextInt(2001)+1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    long time1=System.currentTimeMillis();
                    System.out.println("结束"+name+",结束时间为："+time1);
                }
            });
        }
        es.shutdown();
        while (!es.isTerminated()) {
        }
        long over=System.currentTimeMillis();
        System.out.println("总执行时间为："+(over-start)+"ms");
    }
    //a.参考课上讲述的定长线程池的案例 通过可缓存线程池 去完成下列需求
    //现在餐厅生意越来越好了，老板直接跟大厨说，你能炒多快，就炒多快，灶台随时可以
    //加，好好干，工资不会少。同样用线程池模拟炒五个菜的过程，并且统计炒完共计花费了多久
    public static void demo1(){
        ExecutorService es=Executors.newCachedThreadPool();
        String[] names={"辣椒炒肉","宫保鸡丁","鱼香肉丝","花甲粉","香菇炖鸡"};
        long start=System.currentTimeMillis();
        for (int i=0;i<names.length;i++){
            String name=names[i];
            es.execute(()->{
                System.out.println("开始炒："+name);
                System.out.println("炒完："+name);
            });
        }
        es.shutdown();
        while (!es.isTerminated()){}
        long over=System.currentTimeMillis();
        System.out.println("炒完共计花费了："+(over-start)+"ms");
    }
}
//a.网上购物节的时候，凌晨0点经常发生价格变化，我需要及时获取最新的价格。
//具体要求
//创建价格类`LowPrice`，定义一个价格变量`money`
//创建`Change`线程类，负责修改价格
//创建`Buy`线程类，负责低价购买，如果是原价则一直等
//创建测试类`TestVolatile`
//在测试类中同时启动两个线程
class LowPrice{
    static volatile int money=1000;
}
class Change implements Runnable{
    @Override
    public
    void run() {
        try {
            while (true) {
                synchronized (LowPrice.class) {
                    LowPrice.money+=(new Random().nextInt(201)-100);
                    System.out.println("0点修改价格，当前价格为："+LowPrice.money);
                    LowPrice.class.notify();
                }
                Thread.sleep(3000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
class Buy implements Runnable{
    @Override
    public
    void run() {
        while (true) {
            synchronized (LowPrice.class) {
                while (LowPrice.money>=1000){
                    try {
                        LowPrice.class.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("低价购买到商品，价格为：" + LowPrice.money);
                try {
                    LowPrice.class.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
class TestVolatile{
    public static
    void main(String[] args) {
        Buy b=new Buy();
        Change c=new Change();
        new Thread(c).start();
        new Thread(b).start();
    }

}